/**
 * Notes: 设备状态管理器 - 后台统一管理设备状态
 * Date: 2025-10-04
 */

const timeUtil = require('../../framework/utils/time_util.js');
const DeviceModel = require('../model/device_model.js');
const DeviceOrderModel = require('../model/device_order_model.js');
const config = require('../../config/config.js');

class DeviceStatusManager {
    constructor() {
        this.statusCache = new Map(); // 设备状态缓存
        this.timers = new Map(); // 设备定时器
        this.subscribers = new Map(); // 状态订阅者
        this.isInitialized = false;
    }

    /**
     * 初始化状态管理器
     */
    async initialize() {
        if (this.isInitialized) return;
        
        console.log('初始化设备状态管理器...');
        if (config.TEST_MODE && !config.TEST_CONFIG.ENABLE_REAL_DEVICE_STATUS) {
            console.log('TEST_MODE: 跳过设备状态恢复，使用缓存');
        } else {
            await this.restoreDeviceStatus();
        }
        this.isInitialized = true;
        console.log('设备状态管理器初始化完成');
    }

    /**
     * 启动设备使用
     * @param {string} deviceId 设备ID
     * @param {number} duration 使用时长（分钟）
     * @param {string} orderId 订单ID
     * @param {string} userId 用户ID
     */
    async startDeviceUsage(deviceId, duration, orderId, userId) {
        const startTime = timeUtil.time(); // 毫秒
        const endTime = startTime + duration * 60 * 1000; // 毫秒
        
        console.log(`🚀 启动设备使用: ${deviceId}, 时长: ${duration}分钟, 订单: ${orderId}, 用户: ${userId}`);
        console.log(`开始时间: ${startTime}, 结束时间: ${endTime}`);
        
        // 更新设备状态
        const deviceStatus = {
            deviceId,
            orderId,
            userId, // 添加用户ID绑定
            status: DeviceModel.STATUS.IN_USE, // 使用数字状态 2
            startTime,
            endTime,
            duration: duration * 60, // 总时长（秒）
            remainingTime: duration * 60, // 剩余时间（秒）
            lastUpdateTime: startTime
        };
        
        console.log('📊 生成的设备状态:', JSON.stringify(deviceStatus, null, 2));
        
        // 保存到缓存和数据库
        console.log('💾 保存状态到缓存...');
        this.statusCache.set(deviceId, deviceStatus);
        console.log('✅ 缓存保存完成');
        
        console.log('💾 保存状态到数据库...');
        try {
            await this.saveDeviceStatus(deviceStatus);
            console.log('✅ 数据库保存完成');
        } catch (error) {
            console.error('❌ 数据库保存失败:', error);
            throw error;
        }
        
        // 启动定时器
        console.log('⏰ 启动设备定时器...');
        this.startDeviceTimer(deviceId);
        
        // 通知所有订阅者
        console.log('📢 通知状态变更订阅者...');
        this.notifyStatusChange(deviceId, deviceStatus);
        
        console.log(`🎉 设备启动完成: ${deviceId}`);
        return deviceStatus;
    }

    /**
     * 检查设备使用权限
     * @param {string} deviceId 设备ID
     * @param {string} userId 当前用户ID
     * @returns {Object} 权限检查结果
     */
    async checkDevicePermission(deviceId, userId) {
        const status = this.statusCache.get(deviceId);
        
        // 如果设备未在使用中，任何用户都可以操作
        if (!status || status.status !== DeviceModel.STATUS.IN_USE) {
            return {
                hasPermission: true,
                message: '设备可以操作'
            };
        }
        
        // 如果设备正在使用中，检查是否为同一用户
        if (status.userId === userId) {
            return {
                hasPermission: true,
                message: '用户有权限操作设备'
            };
        }
        
        // 获取设备使用者信息（通过订单获取）
        let currentUserInfo = null;
        if (status.orderId) {
            try {
                const DeviceOrderModel = require('../model/device_order_model.js');
                const orderModel = new DeviceOrderModel();
                const order = await orderModel.getOrderDetail(status.orderId);
                if (order && order.userId) {
                    // 这里可以进一步获取用户昵称等信息
                    currentUserInfo = {
                        userId: order.userId,
                        // 可以添加用户昵称等信息
                    };
                }
            } catch (error) {
                console.error('获取订单信息失败:', error);
            }
        }
        
        return {
            hasPermission: false,
            message: '该设备正在使用中，不能操作',
            currentUser: currentUserInfo,
            deviceStatus: {
                startTime: status.startTime,
                endTime: status.endTime,
                remainingTime: status.remainingTime
            }
        };
    }

    /**
     * 延长设备使用时间
     * @param {string} deviceId 设备ID
     * @param {number} extendDuration 延长时长（分钟）
     * @param {string} extendOrderId 延时订单ID
     * @param {string} userId 用户ID（可选，用于权限检查）
     */
    async extendDeviceUsage(deviceId, extendDuration, extendOrderId, userId = null) {
        // 权限检查：如果提供了用户ID，检查用户是否有权限延时该设备
        if (userId) {
            const permissionResult = await this.checkDevicePermission(deviceId, userId);
            if (!permissionResult.hasPermission) {
                throw new Error(permissionResult.message || '该设备正在使用中，无法操作');
            }
        }
        
        // 如果提供了延时订单ID，从订单中获取最新的 endTime，确保数据一致性
        let newEndTime = null;
        if (extendOrderId) {
            try {
                const DeviceOrderModel = require('../model/device_order_model.js');
                const extendOrder = await DeviceOrderModel.getOne({ _id: extendOrderId }, 'endTime', {}, false);
                if (extendOrder && extendOrder.endTime) {
                    newEndTime = Number(extendOrder.endTime);
                    console.log(`extendDeviceUsage: 从延时订单获取结束时间 orderId=${extendOrderId}, endTime=${newEndTime}`);
                }
            } catch (e) {
                console.warn(`extendDeviceUsage: 获取延时订单信息失败，将使用缓存值计算: ${e.message}`);
            }
        }
        
        let status = this.statusCache.get(deviceId);
        // 容错：若缓存无状态或不是"使用中"，从数据库/订单恢复状态
        if (!status || status.status !== DeviceModel.STATUS.IN_USE) {
            console.warn(`extendDeviceUsage: 缓存缺失或非使用中，尝试从数据库恢复状态 deviceId=${deviceId}`);
            try {
                status = await this.loadDeviceStatus(deviceId);
            } catch (e) {
                console.error('extendDeviceUsage: 加载设备状态失败', e);
            }
            if (status && status.status === DeviceModel.STATUS.IN_USE) {
                this.statusCache.set(deviceId, status);
                // 若没有定时器，补启
                if (!this.timers.has(deviceId)) {
                    this.startDeviceTimer(deviceId);
                }
            } else {
                throw new Error('设备当前不在使用中，无法延时');
            }
        }
        
        console.log(`延长设备使用时间: ${deviceId}, 延长: ${extendDuration}分钟`);
        
        // 若传入延时订单ID，与当前订单不一致，更新为新的延时订单ID
        if (extendOrderId && status.orderId && extendOrderId !== status.orderId) {
            console.log(`extendDeviceUsage: 更新订单ID current=${status.orderId}, extend=${extendOrderId}`);
            // 对于延时订单，更新 orderId 为新的延时订单ID，以便后续查询和管理
            status.orderId = extendOrderId;
        }
        
        // 延长结束时间：优先使用订单中的 endTime，否则基于缓存值延长
        if (newEndTime && newEndTime > 0) {
            // 使用订单中的 endTime，确保与订单数据一致
            const oldEndTime = status.endTime;
            status.endTime = newEndTime;
            // 重新计算剩余时间（基于新的结束时间）
            const currentTime = timeUtil.time();
            status.remainingTime = Math.max(0, Math.floor((status.endTime - currentTime) / 1000)); // 秒
            console.log(`extendDeviceUsage: 使用订单endTime更新状态 oldEndTime=${oldEndTime}, newEndTime=${newEndTime}, remainingTime=${status.remainingTime}`);
        } else {
            // 基于缓存值延长（兼容旧逻辑）
            status.endTime += extendDuration * 60 * 1000; // 毫秒
            status.remainingTime = Math.max(0, status.remainingTime + extendDuration * 60); // 秒
            console.log(`extendDeviceUsage: 基于缓存值延长 endTime=${status.endTime}, remainingTime=${status.remainingTime}`);
        }
        status.lastUpdateTime = timeUtil.time();
        
        // 保存到缓存和数据库（先更新缓存，确保定时器读取到最新值）
        this.statusCache.set(deviceId, status);
        await this.saveDeviceStatus(status);
        
        // 重要：重启定时器，确保定时器立即使用最新的 endTime，避免使用旧的结束时间
        // 这可以防止定时器在延时更新前已经读取了旧的 endTime，导致提前结束
        if (this.timers.has(deviceId)) {
            console.log(`extendDeviceUsage: 重启定时器以确保使用最新的endTime deviceId=${deviceId}`);
            this.startDeviceTimer(deviceId);
        } else {
            // 如果没有定时器，启动一个（理论上不应该发生，但容错处理）
            console.warn(`extendDeviceUsage: 设备正在使用中但没有定时器，启动定时器 deviceId=${deviceId}`);
            this.startDeviceTimer(deviceId);
        }
        
        // 通知订阅者
        this.notifyStatusChange(deviceId, status);
        
        return status;
    }

    /**
     * 启动设备定时器
     * @param {string} deviceId 设备ID
     */
    startDeviceTimer(deviceId) {
        // 清除已存在的定时器
        if (this.timers.has(deviceId)) {
            clearInterval(this.timers.get(deviceId));
        }
        
        // 每10秒更新一次状态（减少频率，提高性能）
        const timer = setInterval(async () => {
            try {
                await this.updateDeviceStatus(deviceId);
            } catch (error) {
                console.error(`更新设备状态失败 ${deviceId}:`, error);
            }
        }, 10000);
        
        this.timers.set(deviceId, timer);
        console.log(`启动设备定时器: ${deviceId}`);
    }

    /**
     * 更新设备状态
     * @param {string} deviceId 设备ID
     */
    async updateDeviceStatus(deviceId) {
        const status = this.statusCache.get(deviceId);
        if (!status || status.status !== DeviceModel.STATUS.IN_USE) {
            return;
        }
    
        const currentTime = timeUtil.time(); // 毫秒
        // 兼容性处理：若缓存中缺少 endTime，则根据 lastUpdateTime + remainingTime 重建
        let endTimeMs = status.endTime;
        if (!endTimeMs) {
            const baseTs = Number(status.lastUpdateTime) || currentTime;
            const rtSec = Number(status.remainingTime) || 0;
            endTimeMs = baseTs + rtSec * 1000;
            status.endTime = endTimeMs;
        }
        const remainingSeconds = Math.max(0, Math.floor((endTimeMs - currentTime) / 1000)); // 秒
    
        // 更新剩余时间（秒）
        status.remainingTime = remainingSeconds;
        status.lastUpdateTime = currentTime;
    
        if (remainingSeconds <= 0) {
            // 时间到期，自动结束使用
            console.log(`设备使用时间到期，自动结束: ${deviceId}`);
            await this.endDeviceUsage(deviceId);
        } else {
            // 更新缓存和数据库
            this.statusCache.set(deviceId, status);
            await this.saveDeviceStatus(status);
    
            // 每整分钟通知一次（秒）
            if (remainingSeconds % 60 === 0) {
                this.notifyStatusChange(deviceId, status);
            }
        }
    }

    /**
     * 结束设备使用
     * @param {string} deviceId 设备ID
     */
    async endDeviceUsage(deviceId, options = {}) {
        const status = this.statusCache.get(deviceId);
        if (!status) return;
        
        console.log(`结束设备使用: ${deviceId}`);
        
        // 更新状态为空闲
        status.status = DeviceModel.STATUS.AVAILABLE; // 使用数字状态 1
        status.remainingTime = 0;
        status.endTime = timeUtil.time();
        status.lastUpdateTime = timeUtil.time();
        
        // 清除定时器
        if (this.timers.has(deviceId)) {
            clearInterval(this.timers.get(deviceId));
            this.timers.delete(deviceId);
            console.log(`清除设备定时器: ${deviceId}`);
        }
        
        // 将订单号缓存并清空，避免重复完成导致循环
        const finishedOrderId = status.orderId;
        status.orderId = '';
        
        // 更新缓存和数据库
        this.statusCache.set(deviceId, status);
        await this.saveDeviceStatus(status);
        
        // 完成订单（测试模式下可根据开关执行数据库操作）
        if (finishedOrderId && (!config.TEST_MODE || config.TEST_CONFIG.ENABLE_REAL_DEVICE_ORDER)) {
            try {
                const DeviceOrderService = require('./device_order_service.js');
                const orderService = new DeviceOrderService();
                await orderService.completeDeviceOrder(finishedOrderId);
                console.log(`完成设备订单: ${finishedOrderId}`);
            } catch (error) {
                console.error(`完成订单失败 ${finishedOrderId}:`, error);
            }
        }
        
        // 控制实体设备关闭（允许跳过，避免重复控制）
        if (!options.skipControl) {
            try {
                const DeviceService = require('./device_service.js');
                const deviceService = new DeviceService();
                await deviceService.controlDevice(deviceId, 'off');
                console.log(`关闭实体设备: ${deviceId}`);
            } catch (error) {
                console.error(`关闭设备失败 ${deviceId}:`, error);
            }
        } else {
            console.log(`跳过实体设备关闭控制（skipControl=true）: ${deviceId}`);
        }
        
        // 通知订阅者
        this.notifyStatusChange(deviceId, status);
    }

    /**
     * 获取设备实时状态
     * @param {string} deviceId 设备ID
     */
    async getDeviceRealTimeStatus(deviceId) {
        let status = this.statusCache.get(deviceId);
        
        // 即使缓存存在，也检查数据库是否有更新
        // 通过比较 lastUpdateTime 来判断是否需要从数据库重新加载
        if (status) {
            try {
                // 快速检查数据库中的 lastUpdateTime
                const device = await DeviceModel.getOne({ _id: deviceId }, 'lastUpdateTime,status,remainingTime,currentOrderId', {}, false);
                if (device) {
                    const dbLastUpdateTime = Number(device.lastUpdateTime) || 0;
                    const cacheLastUpdateTime = Number(status.lastUpdateTime) || 0;
                    
                    // 如果数据库的 lastUpdateTime 更新，或者状态/剩余时间不一致，则重新加载
                    if (dbLastUpdateTime > cacheLastUpdateTime || 
                        Number(device.status) !== status.status ||
                        (Number(device.remainingTime) || 0) !== status.remainingTime) {
                        console.log(`设备 ${deviceId} 数据库状态已更新，重新加载: dbLastUpdate=${dbLastUpdateTime}, cacheLastUpdate=${cacheLastUpdateTime}`);
                        status = await this.loadDeviceStatus(deviceId);
                        if (status) {
                            this.statusCache.set(deviceId, status);
                            // 如果设备正在使用，启动定时器
                            if (status.status === DeviceModel.STATUS.IN_USE && !this.timers.has(deviceId)) {
                                this.startDeviceTimer(deviceId);
                            }
                        }
                    }
                }
            } catch (error) {
                console.error(`检查设备 ${deviceId} 状态更新失败:`, error);
                // 出错时继续使用缓存
            }
        } else {
            // 缓存不存在，从数据库加载状态
            status = await this.loadDeviceStatus(deviceId);
            if (status) {
                this.statusCache.set(deviceId, status);
                // 如果设备正在使用，启动定时器
                if (status.status === DeviceModel.STATUS.IN_USE) {
                    this.startDeviceTimer(deviceId);
                }
            }
        }
        
        return status || {
            deviceId,
            status: DeviceModel.STATUS.AVAILABLE,
            remainingTime: 0,
            lastUpdateTime: timeUtil.time()
        };
    }

    /**
     * 获取门店所有设备状态
     * @param {string} storeId 门店ID（支持_id或storeId）
     */
    async getStoreDevicesStatus(storeId) {
        console.log('=== getStoreDevicesStatus 开始 ===');
        console.log('传入的门店ID:', storeId);

        // 在测试模式下，避免访问数据库，直接从缓存或模拟构造设备列表（可通过TEST_CONFIG关闭）
        if (config.TEST_MODE && !config.TEST_CONFIG.ENABLE_REAL_DEVICE_LIST) {
            const deviceStatuses = [];
            // 从全局设备缓存读取属于该门店的设备
            const allCached = global.DEVICE_CACHE ? Array.from(global.DEVICE_CACHE.values()) : [];
            const list = allCached.filter(d => (d.storeId || '') === (storeId || ''));
            // 如果缓存为空，使用一个模拟设备
            const fallback = list.length > 0 ? list : [{ _id: 'test_device', name: '测试设备', type: 'dryer', storeId: storeId || 'test_store' }];
            for (const device of fallback) {
                // 构造一个可用状态的实时数据，单位保持一致
                const status = await this.getDeviceRealTimeStatus(device._id) || {
                    deviceId: device._id,
                    status: DeviceModel.STATUS.AVAILABLE,
                    remainingTime: 0,
                    startTime: undefined,
                    endTime: undefined,
                    orderId: undefined,
                    lastUpdateTime: timeUtil.time()
                };
                const enriched = this.enrichDeviceInfo({ ...device });
                deviceStatuses.push({
                    ...enriched,
                    status: status.status,
                    remainingTime: status.remainingTime, // 秒
                    startTime: status.startTime, // 毫秒
                    endTime: status.endTime, // 毫秒
                    currentOrderId: status.orderId,
                    lastUpdateTime: status.lastUpdateTime
                });
            }
            console.log('TEST_MODE: 通过缓存/模拟返回设备状态', deviceStatuses.map(s => ({ _id: s._id, name: s.name, status: s.status, remainingTime: s.remainingTime })));
            console.log('=== getStoreDevicesStatus 结束(TEST_MODE) ===');
            return deviceStatuses;
        }

        // 直接使用传入的门店ID，不进行映射转换
        let actualStoreId = storeId;
        console.log('传入的门店ID:', storeId, '类型:', typeof storeId);
        console.log('直接使用门店ID进行设备查询:', actualStoreId);
        
        // 直接使用门店ID查询设备，不使用_pid过滤
        let devices = await DeviceModel.getAll({ 
            storeId: actualStoreId
        }, '*', {}, 100, false);
        const deviceSummary = (devices || []).map(d => ({ _id: d._id, name: d.name, type: d.type, storeId: d.storeId }));
        console.log('查询到的设备数量:', devices ? devices.length : 0);
        console.log('查询到的设备摘要:', deviceSummary);
        
        const deviceStatuses = [];
        for (let device of devices) {
            console.log('处理设备:', device._id, device.name);
            const status = await this.getDeviceRealTimeStatus(device._id);
            
            // 单位一致性校验：remainingTime 应为秒，endTime/startTime 应为毫秒
            const unitCheck = {
                deviceId: device._id,
                hasStatus: !!status,
                remainingTimeIsSeconds: typeof status?.remainingTime === 'number' ? (status.remainingTime < 24 * 3600 + 1) : null,
                endTimeIsMillis: typeof status?.endTime === 'number' ? (status.endTime > 1000 * 60 * 10) : null,
                startTimeIsMillis: typeof status?.startTime === 'number' ? (status.startTime > 1000 * 60 * 10) : null
            };
            console.log('单位一致性校验:', unitCheck);
            
            // 丰富设备信息，添加图标等
            const enrichedDevice = this.enrichDeviceInfo(device);
            
            deviceStatuses.push({
                ...enrichedDevice,
                status: status.status,
                remainingTime: status.remainingTime, // 秒
                endTime: status.endTime, // 毫秒，供前端精确计算剩余秒数
                startTime: status.startTime, // 毫秒
                currentOrderId: status.orderId,
                currentUserId: status.userId || null, // 添加当前使用设备的用户ID
                lastUpdateTime: status.lastUpdateTime
            });
        }
        
        console.log('最终返回的设备状态数组长度:', deviceStatuses.length);
        console.log('最终返回的设备状态数组(摘要):', deviceStatuses.map(s => ({ _id: s._id, name: s.name, status: s.status, remainingTime: s.remainingTime, endTime: s.endTime })));
        console.log('=== getStoreDevicesStatus 结束 ===');
        return deviceStatuses;
    }

    /**
     * 丰富设备信息
     * @param {Object} device 设备信息
     * @returns {Object} 丰富后的设备信息
     */
    enrichDeviceInfo(device) {
        // 根据设备类型添加图标和描述
        switch (device.type) {
            case 'bath':
                device.icon = '/assets/equipment-list/icon_bath.png';
                device.iconUsing = '/assets/equipment-list/icon_bath_use.png';
                device.typeDesc = '洗浴池';
                break;
            case 'dry':
                device.icon = '/assets/equipment-list/icon_dryer.png';
                device.iconUsing = '/assets/equipment-list/icon_dryer_use.png';
                device.typeDesc = '烘干机';
                break;
            case 'blow':
                device.icon = '/assets/equipment-list/icon_hair_dryer.png';
                device.iconUsing = '/assets/equipment-list/icon_hair_dryer_use.png';
                device.typeDesc = '吹风机';
                break;
            case 'access_control':
                device.icon = '/assets/equipment-list/icon_access.png';
                device.iconUsing = '/assets/equipment-list/icon_access_use.png';
                device.typeDesc = '门禁';
                break;
            default:
                device.icon = '/assets/equipment-list/icon_default.png';
                device.iconUsing = '/assets/equipment-list/icon_default_use.png';
                device.typeDesc = '设备';
        }

        return device;
    }

    /**
     * 保存设备状态到数据库
     * @param {Object} status 设备状态
     */
    async saveDeviceStatus(status) {
        // 在测试模式下不落库，仅维持内存状态
        if (config.TEST_MODE && !config.TEST_CONFIG.ENABLE_REAL_DEVICE_STATUS) {
            console.log(`TEST_MODE: skip DB save for device ${status.deviceId}`);
            return;
        }
        console.log(`🔄 开始保存设备状态到数据库: ${status.deviceId}`);
        console.log('状态数据:', JSON.stringify(status, null, 2));
        
        try {
            // 直接使用数字状态值，无需映射
            // 排除EDIT_TIME字段，避免脏数据错误
            // 注意：设备模型中只有 endTime 字段，没有 startTime 字段
            const updateData = {
                status: status.status, // 直接使用数字状态
                remainingTime: status.remainingTime,
                currentOrderId: status.orderId || '',
                endTime: status.endTime || 0, // 保存结束时间（毫秒）
                lastUpdateTime: status.lastUpdateTime
                // 移除 updateTime 字段，让框架自动处理
            };
            
            console.log('准备更新的数据:', JSON.stringify(updateData, null, 2));
            // 并发保护：仅当数据库中 lastUpdateTime <= 当前状态的 lastUpdateTime 时才更新，防止过期的定时器回写覆盖手动结束
            const where = { _id: status.deviceId, lastUpdateTime: ['<=', status.lastUpdateTime] };
            console.log('更新条件:', JSON.stringify(where, null, 2));
            
            const result = await DeviceModel.edit(
                where,
                updateData,
                false // 重要：设置mustPID=false，避免_pid过滤导致更新失败
            );
            
            console.log(`✅ 设备状态保存成功: ${status.deviceId}`);
            console.log('更新结果:', result);
            
        } catch (error) {
            console.error(`❌ 保存设备状态失败 ${status.deviceId}:`, error);
            console.error('错误详情:', error.stack);
            throw error; // 重新抛出错误，让上层知道保存失败
        }
    }

    /**
     * 从数据库加载设备状态
     * @param {string} deviceId 设备ID
     */
    async loadDeviceStatus(deviceId) {
      // 测试模式下直接从内存获取，避免数据库访问（可通过TEST_CONFIG关闭）
      if (config.TEST_MODE && !config.TEST_CONFIG.ENABLE_REAL_DEVICE_STATUS) {
        const cached = this.statusCache.get(deviceId);
        if (cached) return cached;
        return {
          deviceId,
          status: DeviceModel.STATUS.AVAILABLE,
          remainingTime: 0,
          lastUpdateTime: timeUtil.time()
        };
      }
      try {
        const device = await DeviceModel.getOne({ _id: deviceId }, '*', {}, false);
        if (!device) return null;
        
        // 优先使用设备表中的 currentOrderId 查询订单（确保获取最新的延时订单）
        let activeOrder = null;
        if (device.currentOrderId) {
          try {
            activeOrder = await DeviceOrderModel.getOne({
              _id: device.currentOrderId,
              deviceId,
              status: DeviceOrderModel.STATUS.PAID
            }, '*', {}, false);
            if (activeOrder) {
              console.log(`loadDeviceStatus: 使用currentOrderId查询到订单: ${device.currentOrderId}`);
            }
          } catch (e) {
            console.warn(`loadDeviceStatus: 使用currentOrderId查询订单失败: ${e.message}`);
          }
        }
        
        // 如果没有找到订单，查询所有已支付订单，取最新的（按endTime降序）
        if (!activeOrder) {
          const allPaidOrders = await DeviceOrderModel.getAll({
            deviceId,
            status: DeviceOrderModel.STATUS.PAID
          }, '*', {}, 100, false);
          
          if (allPaidOrders && allPaidOrders.length > 0) {
            // 按 endTime 降序排序，取最新的订单
            allPaidOrders.sort((a, b) => (Number(b.endTime) || 0) - (Number(a.endTime) || 0));
            activeOrder = allPaidOrders[0];
            console.log(`loadDeviceStatus: 查询到 ${allPaidOrders.length} 个已支付订单，使用最新的订单: ${activeOrder._id}, endTime=${activeOrder.endTime}`);
          }
        }
        
        if (activeOrder) {
          const currentTime = timeUtil.time();
          const remainingSeconds = Math.max(0, Math.floor((activeOrder.endTime - currentTime) / 1000));
        
          if (remainingSeconds > 0) {
            return {
              deviceId,
              orderId: activeOrder._id,
              userId: activeOrder.userId || undefined, // 添加用户ID
              status: DeviceModel.STATUS.IN_USE,
              startTime: activeOrder.startTime,
              endTime: activeOrder.endTime,
              remainingTime: remainingSeconds, // 秒
              lastUpdateTime: currentTime
            };
          }
        }
        
        // 无活跃订单但设备记录为使用中且有剩余时间时，依据设备表字段重建实时状态
        const deviceStatusNumeric = Number(device.status);
        const deviceRemainingSec = Number(device.remainingTime) || 0;
        const deviceEndTime = Number(device.endTime) || 0; // 优先使用数据库中的 endTime
        const deviceLastUpdate = Number(device.lastUpdateTime) || timeUtil.time();
        if (deviceStatusNumeric === DeviceModel.STATUS.IN_USE && deviceRemainingSec > 0) {
          const currentTime = timeUtil.time();
          // 优先使用数据库中的 endTime，如果没有则根据 lastUpdateTime + remainingTime 重建
          let endTimeMs = deviceEndTime;
          if (!endTimeMs || endTimeMs <= deviceLastUpdate) {
            endTimeMs = deviceLastUpdate + deviceRemainingSec * 1000; // 毫秒
            console.log(`loadDeviceStatus: 设备endTime无效，重建endTime: ${endTimeMs}`);
          }
          const remainingSeconds = Math.max(0, Math.floor((endTimeMs - currentTime) / 1000));
          if (remainingSeconds > 0) {
            // 如果有 currentOrderId，尝试从订单获取 userId
            let userId = undefined;
            if (device.currentOrderId) {
              try {
                const order = await DeviceOrderModel.getOne({ _id: device.currentOrderId }, 'userId', {}, false);
                if (order && order.userId) {
                  userId = order.userId;
                }
              } catch (error) {
                console.error(`获取订单 ${device.currentOrderId} 的用户ID失败:`, error);
              }
            }
            
            return {
              deviceId,
              orderId: device.currentOrderId || undefined,
              userId: userId, // 添加用户ID
              status: DeviceModel.STATUS.IN_USE,
              startTime: device.startTime || undefined,
              endTime: endTimeMs, // 使用数据库中的 endTime 或重建的 endTime
              remainingTime: remainingSeconds,
              lastUpdateTime: currentTime
            };
          }
        }
        
        return {
          deviceId,
          status: deviceStatusNumeric,
          remainingTime: deviceRemainingSec, // 秒
          lastUpdateTime: deviceLastUpdate
        };
      } catch (error) {
        console.error(`加载设备状态失败 ${deviceId}:`, error);
        // 优先返回缓存中的最近状态，避免前端短暂显示空闲
        const cached = this.statusCache.get(deviceId);
        if (cached) return cached;
        return null;
      }
    }

    /**
     * 恢复设备状态（系统启动时调用）
     */
    async restoreDeviceStatus() {
      console.log('开始恢复设备状态...');
      
      // 测试模式：跳过数据库状态恢复，避免云SDK密钥错误
      if (config.TEST_MODE && !config.TEST_CONFIG.ENABLE_REAL_DEVICE_STATUS) {
        console.log('TEST_MODE: 跳过设备状态恢复（不访问数据库）');
        return {
          success: true,
          message: 'TEST_MODE: 跳过设备状态恢复'
        };
      }
      
      try {
        // 获取所有进行中的订单（绕过PID过滤）
        const activeOrders = await DeviceOrderModel.getAll({
          status: DeviceOrderModel.STATUS.PAID
        }, '*', {}, 1000, false);
        
        let restoredCount = 0;
        for (let order of activeOrders) {
          const currentTime = timeUtil.time();
          
          if (currentTime < order.endTime) {
            const remainingSeconds = Math.max(0, Math.floor((order.endTime - currentTime) / 1000));
            const deviceStatus = {
              deviceId: order.deviceId,
              orderId: order._id,
              status: DeviceModel.STATUS.IN_USE,
              startTime: order.startTime,
              endTime: order.endTime,
              remainingTime: remainingSeconds, // 秒
              lastUpdateTime: currentTime
            };
            
            this.statusCache.set(order.deviceId, deviceStatus);
            await this.saveDeviceStatus(deviceStatus);
            this.startDeviceTimer(order.deviceId);
            
            restoredCount++;
          } else {
            const DeviceOrderService = require('./device_order_service.js');
            const orderService = new DeviceOrderService();
            await orderService.completeDeviceOrder(order._id);
          }
        }
        
        console.log(`恢复了 ${restoredCount} 个设备状态`);
        return {
          success: true,
          message: `恢复了 ${restoredCount} 个设备状态`
        };
      } catch (error) {
        console.error('设备状态恢复失败:', error);
        return {
          success: false,
          message: error.message
        };
      }
    }

    /**
     * 通知状态变化
     * @param {string} deviceId 设备ID
     * @param {Object} status 设备状态
     */
    notifyStatusChange(deviceId, status) {
        const subscribers = this.subscribers.get(deviceId) || [];
        subscribers.forEach(callback => {
            try {
                callback(status);
            } catch (error) {
                console.error('通知订阅者失败:', error);
            }
        });
    }

    /**
     * 订阅设备状态变化
     * @param {string} deviceId 设备ID
     * @param {Function} callback 回调函数
     */
    subscribe(deviceId, callback) {
        if (!this.subscribers.has(deviceId)) {
            this.subscribers.set(deviceId, []);
        }
        this.subscribers.get(deviceId).push(callback);
    }

    /**
     * 取消订阅
     * @param {string} deviceId 设备ID
     * @param {Function} callback 回调函数
     */
    unsubscribe(deviceId, callback) {
        const subscribers = this.subscribers.get(deviceId) || [];
        const index = subscribers.indexOf(callback);
        if (index > -1) {
            subscribers.splice(index, 1);
        }
    }

    /**
     * 清理资源
     */
    cleanup() {
        console.log('清理设备状态管理器资源...');
        
        // 清除所有定时器
        for (let [deviceId, timer] of this.timers) {
            clearInterval(timer);
            console.log(`清除定时器: ${deviceId}`);
        }
        
        this.timers.clear();
        this.statusCache.clear();
        this.subscribers.clear();
        this.isInitialized = false;
    }

    /**
     * 获取管理器状态信息
     */
    getManagerStatus() {
        return {
            isInitialized: this.isInitialized,
            cachedDevices: this.statusCache.size,
            activeTimers: this.timers.size,
            subscribers: Array.from(this.subscribers.keys()).length
        };
    }
}

// 全局单例
const deviceStatusManager = new DeviceStatusManager();

// 自动初始化
deviceStatusManager.initialize().catch(error => {
    console.error('设备状态管理器初始化失败:', error);
});

module.exports = deviceStatusManager;